home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / text / hyper / hsc_source.lha / source / hsc / callback.c < prev    next >
C/C++ Source or Header  |  1996-09-09  |  8KB  |  336 lines
  1. /*
  2.  * hsc/callback.c
  3.  *
  4.  * callbacks of hsc for hsclib
  5.  *
  6.  * Copyright (C) 1995,96  Thomas Aglassinger <agi@sbox.tu-graz.ac.at>
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  * updated:  9-Sep-1996
  23.  * created: 17-Mar-1996
  24.  *
  25.  */
  26.  
  27. #include "hsc/global.h"
  28. #include "hsc/output.h"
  29. #include "hsc/status.h"
  30.  
  31. #include "ugly/returncd.h"
  32.  
  33. #define NOEXTERN_HSC_CALLBACK_H
  34. #include "hsc/callback.h"
  35.  
  36.  
  37. /*
  38.  * defines for ANSI-sequences
  39.  */
  40. #define ANSI_RESET     "\033[0m"
  41. #define ANSI_BOLD      "\033[1m"
  42. #define ANSI_ITALIC    "\033[3m"
  43. #define ANSI_UNDERLINE "\033[4m"
  44. #define ANSI_INVERT    "\033[7m"
  45.  
  46. #define ANSI_TEXT_BACKGR "\033[30m"
  47. #define ANSI_TEXT_SHADOW "\033[31m"
  48. #define ANSI_TEXT_HILITE "\033[32m"
  49. #define ANSI_TEXT_STRESS "\033[31m"
  50.  
  51.  
  52. static FILE *msgfile = NULL;
  53.  
  54. /*
  55.  * hsc_nomem_handler
  56.  *
  57.  * called from ugly/umemory/umalloc(), if malloc() did return NULL
  58.  */
  59. BOOL hsc_nomem_handler( size_t size )
  60. {
  61.     status_error( "out of memory" );
  62.  
  63.     return_code = RC_FAIL;
  64.  
  65.     exit( return_code );
  66.  
  67.     return( FALSE ); /* immediatly abort */
  68. }
  69.  
  70.  
  71.  
  72. /*
  73.  * message
  74.  *
  75.  * hsc-callback to display message coming from parser
  76.  */
  77. static VOID message(HSCPRC *hp,
  78.      HSCMSG_CLASS msg_class, HSCMSG_ID msg_id,
  79.      STRPTR fname, ULONG x, ULONG y,
  80.      STRPTR msg_text)
  81. {
  82.     STRPTR msg_class_str = "*UNKNOWN*";
  83.     STRPTR msg_class_seq = ANSI_BOLD;
  84.     STRPTR msgfmt = msg_format;
  85.  
  86.     if  ( !msgfmt )
  87. #if 1
  88.         msgfmt = "%f (%y,%x): %c %i: %m"; /* hsc format */
  89. #else
  90.         msgfmt = "%f:%y: %c %i: %m";      /* 'gcc' format */
  91. #endif
  92.  
  93.     switch ( msg_class ) {
  94.  
  95.         case MSG_NOTE:
  96.             msg_class_str = "Note";
  97.             break;
  98.         case MSG_STYLE:
  99.             msg_class_str = "Bad style";
  100.             break;
  101.         case MSG_PORT:
  102.             msg_class_str = "Portability problem";
  103.             break;
  104.         case MSG_WARN:
  105.             msg_class_str = "Warning";
  106.             break;
  107.         case MSG_ERROR:
  108.             msg_class_str = "Error";
  109.             msg_class_seq = ANSI_BOLD ANSI_TEXT_HILITE;
  110.             break;
  111.         case MSG_FATAL:
  112.             msg_class_str = "Fatal error";
  113.             msg_class_seq = ANSI_BOLD ANSI_TEXT_HILITE;
  114.             break;
  115.  
  116.     }
  117.  
  118.     /* update returncode if necessary */
  119.     if ( msg_class == MSG_WARN )
  120.         set_return_code( RC_WARN );
  121.     else if ( msg_class == MSG_ERROR )
  122.         set_return_code( RC_ERROR );
  123.     else if ( msg_class == MSG_FATAL )
  124.         set_return_code( RC_FAIL );
  125.  
  126.     /* couldn't open include file */
  127.     if ( !fname )
  128.     {
  129.         fname = estr2str( inpfilename );
  130.         x = 1; y = 1;
  131.     }
  132.  
  133.     clr_estr( msgbuf );
  134.     while ( msgfmt[0] )
  135.     {
  136.         if ( msgfmt[0]=='%' )
  137.         {
  138.             msgfmt++;
  139.             switch ( msgfmt[0] )
  140.             {
  141.                 case 'c':
  142.                     if (msg_ansi)
  143.                         app_estr(msgbuf, msg_class_seq);
  144.                     app_estr( msgbuf, msg_class_str );
  145.                     if (msg_ansi)
  146.                         app_estr(msgbuf, ANSI_RESET);
  147.                     break;
  148.                 case 'f':
  149.                     app_estr( msgbuf, fname );
  150.                     break;
  151.                 case 'i':
  152.                     if (msg_ansi)
  153.                         app_estr(msgbuf, msg_class_seq);
  154.                     app_estr( msgbuf, long2str( msg_id ) );
  155.                     if (msg_ansi)
  156.                         app_estr(msgbuf, ANSI_RESET);
  157.                     break;
  158.                 case 'm':
  159.                     app_estr( msgbuf, msg_text );
  160.                     break;
  161.                 case 'n':
  162.                     app_estrch( msgbuf, '\n' );
  163.                     break;
  164.                 case 'x':
  165.                     app_estr( msgbuf, long2str( x ) );
  166.                     break;
  167.                 case 'y':
  168.                     app_estr( msgbuf, long2str( y ) );
  169.                     break;
  170.                 default :
  171.                     app_estrch( msgbuf, '%' );
  172.                     app_estrch( msgbuf, msgfmt[0] );
  173.                     break;
  174.             }
  175.         }
  176.         else
  177.         {
  178.             app_estrch( msgbuf, msgfmt[0] );
  179.         }
  180.         msgfmt++;
  181.     }
  182.     app_estrch( msgbuf, '\n' ); /* append LF */
  183.     fputs( estr2str( msgbuf ), msgfile );
  184.  
  185.     D(
  186.         if ( msgfile != stderr )
  187.             fprintf( stderr, DHSC "msg `%s (%ld,%ld): %s %ld: %s'\n",
  188.                      fname, y, x,
  189.                      msg_class_str, msg_id, msg_text )
  190.     );
  191.  
  192. }
  193.  
  194. /*
  195.  * message_ref
  196.  *
  197.  * hsc-callback to display ref-message coming from parser
  198.  */
  199. static VOID message_ref(HSCPRC *hp,
  200.      HSCMSG_CLASS msg_class, HSCMSG_ID msg_id,
  201.      STRPTR fname, ULONG x, ULONG y,
  202.      STRPTR msg_text)
  203. {
  204.     if ( msg_text && msg_text[0] )
  205.         message( hp, msg_class, msg_id, fname, x, y, msg_text );
  206.     else
  207.         message( hp, msg_class, msg_id, fname, x, y,
  208.                  "(location of previous call)");
  209. }
  210.  
  211. static VOID do_hsc_id( HSCPRC *hp, HSCATTR *attr, STRPTR id )
  212. {
  213. #if 0
  214.     fprintf( stderr, "new id   : `%s' for attr `%s'\n",
  215.              id, attr->name );
  216. #endif
  217. }
  218.  
  219. /*
  220.  * do_hsc_start_tag
  221.  *
  222.  * hsc-callback for processing start tag
  223.  */
  224. static VOID do_hsc_start_tag( HSCPRC *hp, HSCTAG *tag, STRPTR tag_name, STRPTR tag_attr, STRPTR tag_close )
  225. {
  226. #if 0
  227.     if ( tag )
  228.         fprintf( stderr, "start tag: <%s>\n", tag->name );
  229.     else
  230.         fprintf( stderr, "start tag: <UNKNOWN>\n" );
  231. #endif
  232.     append_output( tag_name );
  233.     append_output( tag_attr );
  234.     append_output( tag_close );
  235. }
  236.  
  237. static VOID do_hsc_end_tag( HSCPRC *hp, HSCTAG *tag, STRPTR tag_name, STRPTR tag_attr, STRPTR tag_close )
  238. {
  239. #if 0
  240.     if ( tag )
  241.         fprintf( stderr, "end tag  : </%s>\n", tag->name );
  242.     else
  243.         fprintf( stderr, "start tag: <UNKNOWN>\n" );
  244. #endif
  245.     append_output( tag_name );
  246.     append_output( tag_attr );
  247.     append_output( tag_close );
  248. }
  249.  
  250. static VOID do_hsc_text( HSCPRC *hp, STRPTR whtspc, STRPTR text )
  251. {
  252. #if 0
  253.     fprintf( stderr, "text     : \"%s\", \"%s\"\n", whtspc, text );
  254. #endif
  255.     append_output( whtspc );
  256.     append_output( text );
  257. }
  258.  
  259. /*
  260.  * init_callback
  261.  *
  262.  * assign hsc's callbacks to a hsc-process
  263.  */
  264. BOOL init_callback( HSCPRC *hp )
  265. {
  266.     /* status-messages */
  267.     hsc_set_status_file_begin( hp, status_file_begin );
  268.     hsc_set_status_file_end( hp, status_file_end );
  269.     hsc_set_status_line( hp, status_line );
  270.     hsc_set_status_misc( hp, status_misc );
  271.  
  272.     /* messages */
  273.     hsc_set_message( hp, message );
  274.     hsc_set_message_ref( hp, message_ref );
  275.  
  276.     /* processing tags & text */
  277.     hsc_set_start_tag( hp, do_hsc_start_tag );
  278.     hsc_set_end_tag( hp, do_hsc_end_tag );
  279.     hsc_set_id( hp, do_hsc_id );
  280.     hsc_set_text( hp, do_hsc_text );
  281.  
  282.     return( TRUE );
  283. }
  284.  
  285. /*
  286.  * message file functiuons
  287.  */
  288.  
  289. /*
  290.  * init_msg_file
  291.  *
  292.  * open messagefile or assign it to stdderr
  293.  */
  294. BOOL init_msgfile( HSCPRC *hp, STRPTR fname )
  295. {
  296.     BOOL ok = TRUE;
  297.  
  298.     if ( fname )
  299.     {
  300.         D( fprintf( stderr, DHSC "write msg to `%s'\n", fname ) );
  301.  
  302.         errno = 0;
  303.         msgfile = fopen( fname, "w" );
  304.         if ( !msgfile )
  305.         {
  306. #define MSGBUFLEN 79
  307.             STRARR msgbuf[ MSGBUFLEN+1 ];
  308.  
  309.             strncpy( msgbuf, "unable to open message file `", MSGBUFLEN );
  310.             strncat( msgbuf, fname , MSGBUFLEN - strlen(msgbuf) );
  311.             strncat( msgbuf, "': " , MSGBUFLEN - strlen(msgbuf) );
  312.             strncat( msgbuf, strerror( errno ) , MSGBUFLEN - strlen(msgbuf) );
  313.             status_error( msgbuf );
  314.             ok = FALSE;
  315.         }
  316.     }
  317.     else
  318.     {
  319.         msgfile = stderr;
  320.         D( fprintf( stderr, DHSC "write msg to <stderr>\n" ) );
  321.     }
  322.  
  323.     return( ok );
  324. }
  325.  
  326. /*
  327.  * cleanup_msg_file
  328.  *
  329.  * close message file if neccessary
  330.  */
  331. VOID cleanup_msgfile( VOID )
  332. {
  333.     if ( msgfile && (msgfile != stderr) )
  334.         fclose( msgfile );
  335. }
  336.